home *** CD-ROM | disk | FTP | other *** search
/ Computer Inter@ctive 17 / Computer Interactive cdrom 17 - gen 99.iso / ZDNETIT / CONTENT / OPTIVDOS.ZIP / INCLUDE.ZIP / MCESTD.H < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-21  |  30.0 KB  |  588 lines
  1. /*  MCEstd.h
  2.  
  3.   matrix management functions:
  4.   manipulations on matrices of data type "eComplex"
  5.   (extended-precision complex numbers)
  6.  
  7.   Copyright (c) 1996-1998 by Martin Sander
  8.   All Rights Reserved.
  9. */
  10.  
  11. #if !defined( __MATLIB_H )
  12.    #include <MatLib.h>
  13. #endif
  14. #if !defined( __VCESTD_H )
  15.    #include <VCEstd.h>
  16. #endif
  17.  
  18. #ifdef __cplusplus
  19. extern "C" {
  20. #endif
  21.  
  22. /*************   Dynamic Generation of Matrices   ************************/
  23.  
  24. ceMatrix __vf  MCE_matrix(  unsigned ht, unsigned len );
  25. ceMatrix __vf  MCE_matrix0( unsigned ht, unsigned len );
  26.     /*  Notice that, in the memory model HUGE,
  27.         neither len nor ht may exceed 1637            */
  28.  
  29. /***************************************************************************
  30.  *  The following definitions ensure compatibility between dynamically     *
  31.  *  and statically allocated matrices. The definitions are somewhat        *
  32.  *  cumbersome, but the result for you is that you need not care about     *
  33.  *  the differences between the two types.                                 *
  34.  *  (Internally, the address of the first element of any matrix is needed; *
  35.  *  the expression "MA[0]" is evaluated in a different way for both types, *
  36.  *  but yields in either case the correct address to be passed to the      *
  37.  *  function you wish to call.)                                            *
  38.  *  Only in the rare case that you need to pass the address of one of      *
  39.  *  these functions as an argument to another function, you have to use    *
  40.  *  the actual run-time functions defined further below. Be careful with   *
  41.  *  this: future development of compilers may allow us to avoid this un-   *
  42.  *  handy scheme of macros. So future versions of MatrixLib may no longer  *
  43.  *  use these run-time names.                                              *
  44.  ***************************************************************************/
  45.  
  46.  
  47. /***  Addressing single elements of dynamically allocated matrices: ******
  48.      These two functions are for compatibility with Pascal
  49.      (where elements of dynamically allocated matrices are not directly
  50.      accessible), and for getting around the pointer arithmetics bug in
  51.      some versions of Borland C++.                                     */
  52.  
  53. #define MCE_Pelement( MA, ht, len, m, n ) MCEPelement( MA[0], ht, len, m, n )
  54.                      /* returns a pointer to MA[m][n]. */
  55. #define MCE_element( MA, ht, len, m, n ) *MCEPelement( MA[0], ht, len, m, n )
  56.                      /* dereferenced pointer */
  57.  
  58.  /****************  Initialization  ***************************************
  59.  
  60.     To initialize all elements of a matrix with the same value,
  61.     or to perform arithmetic operations on all elements simultaneously,
  62.     refer to the functions of VectorLib, declared in <VCEstd.h>, <VCEmath.h>.
  63.     In order to use the VectorLib functions, utilize the feature that
  64.     the whole matrix occupies one contiguous area in memory: pass the
  65.     address of the first row to the desired vector function, the size
  66.     of the "vector" being len * ht.
  67.     For example, initialize all elements of the matrix MA with {1.0, 0.0}
  68.     (this is *NOT* the identity matrix)  by calling
  69.         VCE_equ1( MA[0], len * ht );
  70. */
  71.  
  72. #define MCE_equ1( MA, len )                MCEequ1( MA[0], len )
  73.                        /* this is the identity matrix */
  74. #define MCE_outerprod( MA, X, Y, ht, len ) MCEouterprod( MA[0], X, Y, ht, len )
  75.                        /* sizX=ht, sizY=len */
  76. #define MCE_Row_equC( MA, ht, len, iRow, C ) \
  77.                                         MCERow_equC( MA[0], ht, len, iRow, C )
  78. #define MCE_Col_equC( MA, ht, len, iCol, C ) \
  79.                                         MCECol_equC( MA[0], ht, len, iCol, C )
  80. #define MCE_Dia_equC( MA, len, C )      MCEDia_equC( MA[0], len, C )
  81.  
  82. #define MCE_Row_equV( MA, ht, len, iRow, X ) \
  83.                                         MCERow_equV( MA[0], ht, len, iRow, X )
  84. #define MCE_Col_equV( MA, ht, len, iCol, X ) \
  85.                                         MCECol_equV( MA[0], ht, len, iCol, X )
  86. #define MCE_Dia_equV( MA, len, X )      MCEDia_equV( MA[0], len, X )
  87.  
  88. #define MCE_equM( MB, MA, ht, len )  VCE_equV( MB[0], MA[0], ((ui)(len))*(ht) )
  89.  
  90. #define MCE_UequL( MA, len ) MCEUequL( MA[0], len )
  91. #define MCE_LequU( MA, len ) MCELequU( MA[0], len )
  92.          /* copy lower-diagonal elements into upper-diagonal
  93.            (or vice versa) by index-reflection, so as to
  94.            get a symmetric matrix    */
  95.  
  96.             /* data-type conversions:  */
  97. #define M_CEtoCF( MCF, MCE, ht, len ) V_CEtoCF( MCF[0], MCE[0], ((ui)ht)*len )
  98. #define M_CFtoCE( MCE, MCF, ht, len ) V_CFtoCE( MCE[0], MCF[0], ((ui)ht)*len )
  99. #define M_CEtoCD( MCD, MCE, ht, len ) V_CEtoCD( MCD[0], MCE[0], ((ui)ht)*len )
  100. #define M_CDtoCE( MCE, MCD, ht, len ) V_CDtoCE( MCE[0], MCD[0], ((ui)ht)*len )
  101.  
  102. /********  Extracting a submatrix and copying a submatrix back  *********/
  103.  
  104. #define MCE_submatrix( MSub, subHt, subLen, \
  105.                        MSrce, srceHt, srceLen, \
  106.                        firstRowInCol, sampInCol, firstColInRow, sampInRow ) \
  107.                MCEsubmatrix(  MSub[0], subHt, subLen, \
  108.                               MSrce[0], srceHt, srceLen, \
  109.                               firstRowInCol, sampInCol, firstColInRow, sampInRow )
  110.  
  111. #define MCE_submatrix_equM( MDest, destHt, destLen, \
  112.                             firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  113.                             MSrce, srceHt, srceLen ) \
  114.                MCEsubmatrix_equM(  MDest[0], destHt, destLen, \
  115.                              firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  116.                              MSrce[0], srceHt, srceLen )
  117.  
  118. /*****   Extracting a single row or a single column or the diagonal  ******
  119.  *       and storing it into a vector                                     */
  120.  
  121. #define MCE_Row_extract( Y, MA, ht, len, iRow ) \
  122.                                      MCERow_extract( Y, MA[0], ht, len, iRow )
  123. #define MCE_Col_extract( Y, MA, ht, len, iCol ) \
  124.                                      MCECol_extract( Y, MA[0], ht, len, iCol )
  125. #define MCE_Dia_extract( Y, MA, len ) MCEDia_extract( Y, MA[0], len )
  126.  
  127.  
  128. /*****************    Basic arithmetic operations *********************
  129.                       performed on one single row,
  130.                       or one single column of any matrix,
  131.                       or on the diagonal of a square matrix
  132.  
  133.     Note: In contrast to the analogous VectorLib functions, the operations
  134.     are performed in-place, i.e. the input matrix itself is changed  */
  135.  
  136. #define MCE_Row_addC( MA, ht, len, iRow, C ) \
  137.                                      MCERow_addC( MA[0], ht, len, iRow, C )
  138. #define MCE_Col_addC( MA, ht, len, iCol, C ) \
  139.                                      MCECol_addC( MA[0], ht, len, iCol, C )
  140. #define MCE_Dia_addC( MA, len, C )   MCEDia_addC( MA[0], len, C )
  141.  
  142. #define MCE_Row_addV( MA, ht, len, iRow, X ) \
  143.                                      MCERow_addV( MA[0], ht, len, iRow, X )
  144. #define MCE_Col_addV( MA, ht, len, iCol, X ) \
  145.                                      MCECol_addV( MA[0], ht, len, iCol, X )
  146. #define MCE_Dia_addV( MA, len, X )   MCEDia_addV( MA[0], len, X )
  147.  
  148. #define MCE_Row_subC( MA, ht, len, iRow, C ) \
  149.                                      MCERow_addC( MA[0], ht, len, iRow, (-C) )
  150. #define MCE_Col_subC( MA, ht, len, iCol, C ) \
  151.                                      MCECol_addC( MA[0], ht, len, iCol, (-C) )
  152. #define MCE_Dia_subC( MA, len, C )   MCEDia_addC( MA[0], len, (-C) )
  153.  
  154. #define MCE_Row_subV( MA, ht, len, iRow, X ) \
  155.                                      MCERow_subV( MA[0], ht, len, iRow, X )
  156. #define MCE_Col_subV( MA, ht, len, iCol, X ) \
  157.                                      MCECol_subV( MA[0], ht, len, iCol, X )
  158. #define MCE_Dia_subV( MA, len, X )   MCEDia_subV( MA[0], len, X )
  159.  
  160. #define MCE_Row_subrC( MA, ht, len, iRow, C ) \
  161.                                      MCERow_subrC( MA[0], ht, len, iRow, C )
  162. #define MCE_Col_subrC( MA, ht, len, iCol, C ) \
  163.                                      MCECol_subrC( MA[0], ht, len, iCol, C )
  164. #define MCE_Dia_subrC( MA, len, C )  MCEDia_subrC( MA[0], len, C )
  165.  
  166. #define MCE_Row_subrV( MA, ht, len, iRow, X ) \
  167.                                      MCERow_subrV( MA[0], ht, len, iRow, X )
  168. #define MCE_Col_subrV( MA, ht, len, iCol, X ) \
  169.                                      MCECol_subrV( MA[0], ht, len, iCol, X )
  170. #define MCE_Dia_subrV( MA, len, X )  MCEDia_subrV( MA[0], len, X )
  171.  
  172. #define MCE_Row_mulC( MA, ht, len, iRow, C ) \
  173.                                      MCERow_mulC( MA[0], ht, len, iRow, C )
  174. #define MCE_Col_mulC( MA, ht, len, iCol, C ) \
  175.                                      MCECol_mulC( MA[0], ht, len, iCol, C )
  176. #define MCE_Dia_mulC( MA, len, C )   MCEDia_mulC( MA[0], len, C )
  177.  
  178. #define MCE_Row_mulV( MA, ht, len, iRow, X ) \
  179.                                      MCERow_mulV( MA[0], ht, len, iRow, X )
  180. #define MCE_Col_mulV( MA, ht, len, iCol, X ) \
  181.                                      MCECol_mulV( MA[0], ht, len, iCol, X )
  182. #define MCE_Dia_mulV( MA, len, X )   MCEDia_mulV( MA[0], len, X )
  183.  
  184. #define MCE_Row_divC( MA, ht, len, iRow, C ) \
  185.                                      MCERow_divC( MA[0], ht, len, iRow, C )
  186. #define MCE_Col_divC( MA, ht, len, iCol, C ) \
  187.                                      MCECol_divC( MA[0], ht, len, iCol, C )
  188. #define MCE_Dia_divC( MA, len, C )   MCEDia_divC( MA[0], len, C )
  189.  
  190. #define MCE_Row_divV( MA, ht, len, iRow, X ) \
  191.                                       MCERow_divV( MA[0], ht, len, iRow, X )
  192. #define MCE_Col_divV( MA, ht, len, iCol, X ) \
  193.                                       MCECol_divV( MA[0], ht, len, iCol, X )
  194. #define MCE_Dia_divV( MA, len, X )    MCEDia_divV( MA[0], len, X )
  195.  
  196. #define MCE_Row_divrC( MA, ht, len, iRow, C ) \
  197.                                       MCERow_divrC( MA[0], ht, len, iRow, C )
  198. #define MCE_Col_divrC( MA, ht, len, iCol, C ) \
  199.                                       MCECol_divrC( MA[0], ht, len, iCol, C )
  200. #define MCE_Dia_divrC( MA, len, C )   MCEDia_divrC( MA[0], len, C )
  201.  
  202. #define MCE_Row_divrV( MA, ht, len, iRow, X ) \
  203.                                       MCERow_divrV( MA[0], ht, len, iRow, X )
  204. #define MCE_Col_divrV( MA, ht, len, iCol, X ) \
  205.                                       MCECol_divrV( MA[0], ht, len, iCol, X )
  206. #define MCE_Dia_divrV( MA, len, X )   MCEDia_divrV( MA[0], len, X )
  207.  
  208.  
  209. /******  One-dimensional vector operations **********************
  210.          performed along all rows or all columns simultaneously,
  211.          or along the diagonal of a square matrix                */
  212.  
  213. #define MCE_Rows_absmax( Y, MA, ht, len )  MCERows_absmax( Y, MA[0], ht, len )
  214. #define MCE_Cols_absmax( Y, MA, ht, len )  MCECols_absmax( Y, MA[0], ht, len )
  215. #define MCE_Dia_absmax( MA, len )          MCEDia_absmax( MA[0], len )
  216. #define MCE_Rows_absmin( Y, MA, ht, len )  MCERows_absmin( Y, MA[0], ht, len )
  217. #define MCE_Cols_absmin( Y, MA, ht, len )  MCECols_absmin( Y, MA[0], ht, len )
  218. #define MCE_Dia_absmin( MA, len )          MCEDia_absmin( MA[0], len )
  219.  
  220. #define MCE_Rows_maxReIm( Y, MA, ht, len ) MCERows_maxReIm( Y, MA[0], ht, len )
  221. #define MCE_Cols_maxReIm( Y, MA, ht, len ) MCECols_maxReIm( Y, MA[0], ht, len )
  222. #define MCE_Dia_maxReIm( MA, len )         MCEDia_maxReIm( MA[0], len )
  223. #define MCE_Rows_minReIm( Y, MA, ht, len ) MCERows_minReIm( Y, MA[0], ht, len )
  224. #define MCE_Cols_minReIm( Y, MA, ht, len ) MCECols_minReIm( Y, MA[0], ht, len )
  225. #define MCE_Dia_minReIm( MA, len )         MCEDia_minReIm( MA[0], len )
  226.  
  227. #define MCE_Rows_absmaxReIm( Y, MA, ht, len ) MCERows_absmaxReIm( Y, MA[0], ht, len )
  228. #define MCE_Cols_absmaxReIm( Y, MA, ht, len ) MCECols_absmaxReIm( Y, MA[0], ht, len )
  229. #define MCE_Dia_absmaxReIm( MA, len )         MCEDia_absmaxReIm( MA[0], len )
  230. #define MCE_Rows_absminReIm( Y, MA, ht, len ) MCERows_absminReIm( Y, MA[0], ht, len )
  231. #define MCE_Cols_absminReIm( Y, MA, ht, len ) MCECols_absminReIm( Y, MA[0], ht, len )
  232. #define MCE_Dia_absminReIm( MA, len )         MCEDia_absminReIm( MA[0], len )
  233.  
  234. #define MCE_Rows_sum( Y, MA, ht, len )     MCERows_sum( Y, MA[0], ht, len )
  235. #define MCE_Cols_sum( Y, MA, ht, len )     MCECols_sum( Y, MA[0], ht, len )
  236. #define MCE_Dia_sum(  MA, len )            MCEDia_sum( MA[0], len )
  237. #define MCE_Rows_prod( Y, MA, ht, len )    MCERows_prod( Y, MA[0], ht, len )
  238. #define MCE_Cols_prod( Y, MA, ht, len )    MCECols_prod( Y, MA[0], ht, len )
  239. #define MCE_Dia_prod(  MA, len )           MCEDia_prod( MA[0], len )
  240.  
  241. #define MCE_Rows_runsum( MA, ht, len )     MCERows_runsum( MA[0], ht, len )
  242. #define MCE_Cols_runsum( MA, ht, len )     MCECols_runsum( MA[0], ht, len )
  243. #define MCE_Rows_runprod( MA, ht, len )    MCERows_runprod( MA[0], ht, len )
  244. #define MCE_Cols_runprod( MA, ht, len )    MCECols_runprod( MA[0], ht, len )
  245.  
  246. #define MCE_Rows_rotate( MA, ht, len, pos) MCERows_rotate( MA[0], ht, len, pos )
  247. #define MCE_Cols_rotate( MA, ht, len, pos) MCECols_rotate( MA[0], ht, len, pos )
  248.  
  249. /********  Operations involving two rows or two colums of one matrix  *****/
  250.  
  251. #define MCE_Rows_exchange( MA, ht, len, row1, row2 ) \
  252.                              MCERows_exchange( MA[0], ht, len, row1, row2 )
  253. #define MCE_Cols_exchange( MA, ht, len, col1, col2 ) \
  254.                              MCECols_exchange( MA[0], ht, len, col1, col2 )
  255.  
  256. #define MCE_Rows_add( MA, ht, len, destRow, srceRow ) \
  257.                              MCERows_add( MA[0], ht, len, destRow, srceRow )
  258. #define MCE_Cols_add( MA, ht, len, destCol, srceCol ) \
  259.                              MCECols_add( MA[0], ht, len, destCol, srceCol )
  260.                          /* dest[i] += source[i]  */
  261.  
  262. #define MCE_Rows_sub( MA, ht, len, destRow, srceRow ) \
  263.                              MCERows_sub( MA[0], ht, len, destRow, srceRow )
  264. #define MCE_Cols_sub( MA, ht, len, destCol, srceCol ) \
  265.                              MCECols_sub( MA[0], ht, len, destCol, srceCol )
  266.                          /* dest[i] -= source[i]  */
  267.  
  268. #define MCE_Rows_Cadd( MA, ht, len, destRow, srceRow, C ) \
  269.                           MCERows_Cadd( MA[0], ht, len, destRow, srceRow, C )
  270. #define MCE_Cols_Cadd( MA, ht, len, destCol, srceCol, C ) \
  271.                           MCECols_Cadd( MA[0], ht, len, destCol, srceCol, C )
  272.                          /* dest[i] += C * source[i]  */
  273.  
  274. #define MCE_Rows_lincomb( MA, ht, len, destRow, destC, srceRow, srceC ) \
  275.             MCERows_lincomb( MA[0], ht, len, destRow, destC, srceRow, srceC )
  276. #define MCE_Cols_lincomb( MA, ht, len, destCol, destC, srceCol, srceC ) \
  277.             MCECols_lincomb( MA[0], ht, len, destCol, destC, srceCol, srceC )
  278.   /*  linear combination: dest[i] = destC * dest[i] + sourceC * source[i] */
  279.  
  280.  
  281. /*************************  Transposing a matrix **********************/
  282.  
  283. #define MCE_transpose( MTr, MA, htTr, lenTr ) \
  284.              MCEtranspose( MTr[0], MA[0], htTr, lenTr )
  285.        /*  the dimensions htTr, lenTr are those of the transposed matrix,
  286.            not of the original!                */
  287.  
  288.  
  289. /************************ Matrix Multiplication *************************/
  290.  
  291. #define MCE_mulV( Y, MA, X, htA, lenA ) \
  292.                     MCEmulV( Y, MA[0], X, htA, lenA )
  293.                           /*  Y = MA * X.  sizX=lenA, sizY=htA
  294.                               both X and Y are column-vectors    */
  295. #define VCE_mulM( Y, X, MA, sizX, lenA ) \
  296.                     VCEmulM( Y, X, MA[0], 1, sizX, lenA )
  297.                          /*  Y = X * MA.  htA=sizX, sizY=lenA
  298.                              both X and Y are row-vectors.
  299.                              Mind the prefix: VCE_ (not MCE_)    */
  300. #define MCE_mulM( MC, MA, MB, htA, lenA, lenB ) \
  301.                     MCEmulM( MC[0], MA[0], MB[0], htA, lenA, lenB )
  302.                          /*  MC = MA * MB.  htB=lenA, htC=htA, lenC=lenB */
  303.  
  304. /***************** Two-Dimensional Fourier-Transform Methods ************/
  305.  
  306. #define MCEl_FFT( MY, MX, ht, len, dir )     MCElFFT( MY[0], MX[0], ht, len, dir )
  307. #define MCEl_filter( MY, MX, MFlt, ht, len ) MCElfilter( MY[0], MX[0], MFlt[0], ht, len )
  308.  
  309. #define MCEs_FFT( MY, MX, ht, len, dir )     MCEsFFT( MY[0], MX[0], ht, len, dir )
  310. #define MCEs_filter( MY, MX, MFlt, ht, len ) MCEsfilter( MY[0], MX[0], MFlt[0], ht, len )
  311.  
  312. #if defined( __LARGE__ ) || defined( __COMPACT__ ) || defined ( __HUGE__ )
  313.    #define MCE_FFT         MCEl_FFT
  314.    #define MCE_filter      MCEl_filter
  315. #else
  316.    #define MCE_FFT         MCEs_FFT
  317.    #define MCE_filter      MCEs_filter
  318. #endif
  319.  
  320.  
  321. /**************************  Input and Output  **************************/
  322.  
  323. #define MCE_fprint( stream, MA, ht, len, linewidth ) \
  324.                     MCEfprint( stream, MA[0], ht, len, linewidth )
  325. #define MCE_print( MA, ht, len )  MCEfprint( stdout, MA[0], ht, len, 80 )
  326.                     /*  MCE_print is usable only for DOS and EasyWin!  */
  327. #ifndef _Windows
  328.     #define MCE_cprint( MA, ht, len ) MCEcprint( MA[0], ht, len )
  329. #endif
  330.  
  331. #define MCE_write( str, MA, ht, len )   MCEwrite( str, MA[0], ht, len )
  332. #define MCE_read( MA, ht, len, str )    MCEread( MA[0], ht, len, str )
  333. #define MCE_setWriteFormat              VCE_setWriteFormat
  334. #define MCE_setWriteSeparate            VCE_setNWriteSeparate
  335.                                    /* write and read in ascii format */
  336. #define MCE_store( str, MA, ht, len ) \
  337.                            VCE_store( str, MA[0], ((ui)(len))*(ht) );
  338. #define MCE_recall( MA, ht, len, str) \
  339.                            VCE_recall( MA[0], ((ui)(len))*(ht), str);
  340.                                   /* store and recall in binary format */
  341.  
  342.  
  343. /*************************************************************************
  344.  * Here are now the actual declarations of the functions used internally.*
  345.  * These declarations may change in future versions of MatrixLib!        *
  346.  * You should not care too much about them, except in the case you need  *
  347.  * the actual address of a run-time function (see above). Under all      *
  348.  * "normal" circumstances, use only the names defined above in the       *
  349.  * macro section!                                                        *
  350.  *************************************************************************/
  351.  
  352. eComplex _VFAR * MCEPelement( cePMatrix X, unsigned ht, unsigned len,
  353.                          unsigned m, unsigned n );
  354.                   /* pointer is normalized in memory model HUGE */
  355.  
  356. void   __vf  MCEequ1( cePMatrix MA, unsigned len );  /* identity matrix */
  357. void   __vf  MCEouterprod( cePMatrix MA, ceVector X,  ceVector Y,
  358.                            unsigned ht, unsigned len );
  359.  
  360. void   __vf  MCERow_equC( cePMatrix MA, unsigned ht, unsigned len,
  361.                          unsigned iRow, eComplex C );
  362. void   __vf  MCECol_equC( cePMatrix MA, unsigned ht, unsigned len,
  363.                          unsigned iCol, eComplex C );
  364. void   __vf  MCEDia_equC( cePMatrix MA, unsigned len, eComplex C );
  365.  
  366. void   __vf  MCERow_equV( cePMatrix MA, unsigned ht, unsigned len,
  367.                          unsigned iRow, ceVector X );
  368. void   __vf  MCECol_equV( cePMatrix MA, unsigned ht, unsigned len,
  369.                          unsigned iCol, ceVector X );
  370. void   __vf  MCEDia_equV( cePMatrix MA, unsigned len, ceVector X );
  371.  
  372. void   __vf  MCEUequL( cePMatrix MA, unsigned len );
  373. void   __vf  MCELequU( cePMatrix MA, unsigned len );
  374.  
  375. /********  Extracting a submatrix and copying a submatrix back  *********/
  376.  
  377. void  __vf  MCEsubmatrix( cePMatrix MSub,
  378.                           unsigned subHt,  unsigned subLen,
  379.                           cePMatrix MSrce,
  380.                           unsigned srceHt,  unsigned srceLen,
  381.                           unsigned firstRowInCol,  unsigned sampInCol,
  382.                           unsigned firstColInRow,  unsigned sampInRow );
  383.  
  384. void  __vf  MCEsubmatrix_equM( cePMatrix MDest,
  385.                                unsigned destHt,     unsigned destLen,
  386.                                unsigned firstRowInCol,  unsigned sampInCol,
  387.                                unsigned firstColInRow,  unsigned sampInRow,
  388.                                cePMatrix MSrce,
  389.                                unsigned srceHt,     unsigned srceLen );
  390.  
  391.  
  392. /*****   Extracting a single row or a single column or the diagonal  *****
  393.  *       and storing it into a vector                                    */
  394.  
  395. void __vf MCERow_extract( ceVector Y, cePMatrix MA, unsigned ht, unsigned len,
  396.                            unsigned iRow );
  397. void __vf MCECol_extract( ceVector Y, cePMatrix MA, unsigned ht, unsigned len,
  398.                            unsigned iCol );
  399. void __vf MCEDia_extract( ceVector Y, cePMatrix MA, unsigned len );
  400.  
  401.  
  402. /*****************    Basic arithmetic operations ***********************
  403.      performed on one single row,  or one single column of any matrix,
  404.      or on the diagonal of a square matrix                              */
  405.  
  406. void   __vf  MCERow_addC( cePMatrix MA, unsigned ht, unsigned len,
  407.                          unsigned iRow, eComplex C );
  408. void   __vf  MCECol_addC( cePMatrix MA, unsigned ht, unsigned len,
  409.                          unsigned iCol, eComplex C );
  410. void   __vf  MCEDia_addC( cePMatrix MA, unsigned len, eComplex C );
  411.  
  412. void   __vf  MCERow_subC( cePMatrix MA, unsigned ht, unsigned len,
  413.                          unsigned iRow, eComplex C );
  414. void   __vf  MCECol_subC( cePMatrix MA, unsigned ht, unsigned len,
  415.                          unsigned iCol, eComplex C );
  416. void   __vf  MCEDia_subC( cePMatrix MA, unsigned len, eComplex C );
  417.  
  418. void   __vf  MCERow_addV( cePMatrix MA, unsigned ht, unsigned len,
  419.                          unsigned iRow, ceVector X );
  420. void   __vf  MCECol_addV( cePMatrix MA, unsigned ht, unsigned len,
  421.                          unsigned iCol, ceVector X );
  422. void   __vf  MCEDia_addV( cePMatrix MA, unsigned len, ceVector X );
  423.  
  424. void   __vf  MCERow_subV( cePMatrix MA, unsigned ht, unsigned len,
  425.                          unsigned iRow, ceVector X );
  426. void   __vf  MCECol_subV( cePMatrix MA, unsigned ht, unsigned len,
  427.                          unsigned iCol, ceVector X );
  428. void   __vf  MCEDia_subV( cePMatrix MA, unsigned len, ceVector X );
  429.  
  430. void   __vf  MCERow_subrC( cePMatrix MA, unsigned ht, unsigned len,
  431.                          unsigned iRow, eComplex C );
  432. void   __vf  MCECol_subrC( cePMatrix MA, unsigned ht, unsigned len,
  433.                          unsigned iCol, eComplex C );
  434. void   __vf  MCEDia_subrC( cePMatrix MA, unsigned len, eComplex C );
  435.  
  436. void   __vf  MCERow_subrV( cePMatrix MA, unsigned ht, unsigned len,
  437.                          unsigned iRow, ceVector X );
  438. void   __vf  MCECol_subrV( cePMatrix MA, unsigned ht, unsigned len,
  439.                          unsigned iCol, ceVector X );
  440. void   __vf  MCEDia_subrV( cePMatrix MA, unsigned len, ceVector X );
  441.  
  442. void   __vf  MCERow_mulC( cePMatrix MA, unsigned ht, unsigned len,
  443.                          unsigned iRow, eComplex C );
  444. void   __vf  MCECol_mulC( cePMatrix MA, unsigned ht, unsigned len,
  445.                          unsigned iCol, eComplex C );
  446. void   __vf  MCEDia_mulC( cePMatrix MA, unsigned len, eComplex C );
  447.  
  448. void   __vf  MCERow_mulV( cePMatrix MA, unsigned ht, unsigned len,
  449.                          unsigned iRow, ceVector X );
  450. void   __vf  MCECol_mulV( cePMatrix MA, unsigned ht, unsigned len,
  451.                          unsigned iCol, ceVector X );
  452. void   __vf  MCEDia_mulV( cePMatrix MA, unsigned len, ceVector X );
  453.  
  454. void   __vf  MCERow_divC( cePMatrix MA, unsigned ht, unsigned len,
  455.                          unsigned iRow, eComplex C );
  456. void   __vf  MCECol_divC( cePMatrix MA, unsigned ht, unsigned len,
  457.                          unsigned iCol, eComplex C );
  458. void   __vf  MCEDia_divC( cePMatrix MA, unsigned len, eComplex C );
  459.  
  460. void   __vf  MCERow_divV( cePMatrix MA, unsigned ht, unsigned len,
  461.                          unsigned iRow, ceVector X );
  462. void   __vf  MCECol_divV( cePMatrix MA, unsigned ht, unsigned len,
  463.                          unsigned iCol, ceVector X );
  464. void   __vf  MCEDia_divV( cePMatrix MA, unsigned len, ceVector X );
  465.  
  466. void   __vf  MCERow_divrC( cePMatrix MA, unsigned ht, unsigned len,
  467.                          unsigned iRow, eComplex C );
  468. void   __vf  MCECol_divrC( cePMatrix MA, unsigned ht, unsigned len,
  469.                          unsigned iCol, eComplex C );
  470. void   __vf  MCEDia_divrC( cePMatrix MA, unsigned len, eComplex C );
  471.  
  472. void   __vf  MCERow_divrV( cePMatrix MA, unsigned ht, unsigned len,
  473.                          unsigned iRow, ceVector X );
  474. void   __vf  MCECol_divrV( cePMatrix MA, unsigned ht, unsigned len,
  475.                          unsigned iCol, ceVector X );
  476. void   __vf  MCEDia_divrV( cePMatrix MA, unsigned len, ceVector X );
  477.  
  478.  
  479. /******  One-dimensional vector operations **********************
  480.          performed along all rows or all columns simultaneously,
  481.          or along the diagonal of a square matrix                */
  482.  
  483. void     __vf  MCERows_absmax( eVector Y, cePMatrix MA, unsigned ht, unsigned len );
  484. void     __vf  MCECols_absmax( eVector Y, cePMatrix MA, unsigned ht, unsigned len );
  485. extended __vf  MCEDia_absmax(  cePMatrix MA, unsigned len );
  486. void     __vf  MCERows_absmin( eVector Y, cePMatrix MA, unsigned ht, unsigned len );
  487. void     __vf  MCECols_absmin( eVector Y, cePMatrix MA, unsigned ht, unsigned len );
  488. extended __vf  MCEDia_absmin(  cePMatrix MA, unsigned len );
  489.  
  490. void     __vf  MCERows_maxReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  491. void     __vf  MCECols_maxReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  492. eComplex __vf  MCEDia_maxReIm(  cePMatrix MA, unsigned len );
  493. void     __vf  MCERows_minReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  494. void     __vf  MCECols_minReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  495. eComplex __vf  MCEDia_minReIm(  cePMatrix MA, unsigned len );
  496.  
  497. void     __vf  MCERows_absmaxReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  498. void     __vf  MCECols_absmaxReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  499. eComplex __vf  MCEDia_absmaxReIm(  cePMatrix MA, unsigned len );
  500. void     __vf  MCERows_absminReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  501. void     __vf  MCECols_absminReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  502. eComplex __vf  MCEDia_absminReIm(  cePMatrix MA, unsigned len );
  503.  
  504. void     __vf  MCERows_sum( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  505. void     __vf  MCECols_sum( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  506. eComplex __vf  MCEDia_sum(  cePMatrix MA, unsigned len );
  507. void     __vf  MCERows_prod(ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  508. void     __vf  MCECols_prod(ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  509. eComplex __vf  MCEDia_prod( cePMatrix MA, unsigned len );
  510.  
  511.  
  512. void  __vf  MCERows_runsum( cePMatrix MA, unsigned ht, unsigned len );
  513. void  __vf  MCECols_runsum( cePMatrix MA, unsigned ht, unsigned len );
  514. void  __vf  MCERows_runprod( cePMatrix MA, unsigned ht, unsigned len );
  515. void  __vf  MCECols_runprod( cePMatrix MA, unsigned ht, unsigned len );
  516.  
  517. void  __vf  MCERows_rotate( cePMatrix MA, unsigned ht, unsigned len, int pos );
  518. void  __vf  MCECols_rotate( cePMatrix MA, unsigned ht, unsigned len, int pos );
  519.  
  520. /********  Operations involving two rows or two colums of one matrix  *****/
  521.  
  522. void   __vf  MCERows_exchange( cePMatrix MA, unsigned ht, unsigned len,
  523.                               unsigned i1, unsigned i2 );
  524. void   __vf  MCECols_exchange( cePMatrix MA, unsigned ht, unsigned len,
  525.                               unsigned i1, unsigned i2 );
  526.  
  527. void   __vf  MCERows_add( cePMatrix MA, unsigned ht, unsigned len,
  528.                           unsigned destRow, unsigned sourceRow );
  529. void   __vf  MCECols_add( cePMatrix MA, unsigned ht, unsigned len,
  530.                           unsigned destCol, unsigned sourceCol );
  531.  
  532. void   __vf  MCERows_sub( cePMatrix MA, unsigned ht, unsigned len,
  533.                           unsigned destRow, unsigned sourceRow );
  534. void   __vf  MCECols_sub( cePMatrix MA, unsigned ht, unsigned len,
  535.                           unsigned destCol, unsigned sourceCol );
  536.  
  537. void   __vf  MCERows_Cadd( cePMatrix MA, unsigned ht, unsigned len,
  538.                            unsigned destRow, unsigned sourceRow, eComplex C );
  539. void   __vf  MCECols_Cadd( cePMatrix MA, unsigned ht, unsigned len,
  540.                            unsigned destCol, unsigned sourceCol, eComplex C );
  541.  
  542. void   __vf  MCERows_lincomb( cePMatrix MA, unsigned ht, unsigned len,
  543.                               unsigned destRow,  eComplex  destC,
  544.                               unsigned srceRow,  eComplex  srceC );
  545. void   __vf  MCECols_lincomb( cePMatrix MA, unsigned ht, unsigned len,
  546.                               unsigned destCol,  eComplex  destC,
  547.                               unsigned srceCol,  eComplex  srceC );
  548.  
  549.  
  550. /*************************  Transposing a matrix **********************/
  551.  
  552. void  __vf  MCEtranspose( cePMatrix MTr, cePMatrix MA,
  553.                           unsigned htTr, unsigned lenTr );
  554.  
  555.  
  556. /************************ Matrix Multiplication *************************/
  557.  
  558. void  __vf  MCEmulV( ceVector Y, cePMatrix MA, ceVector X,
  559.                      unsigned htA, unsigned lenA );
  560. void  __vf  VCEmulM( ceVector Y, ceVector X, cePMatrix MA,
  561.                      unsigned sizX, unsigned lenA );
  562. void  __vf  MCEmulM( cePMatrix MC, cePMatrix MA, cePMatrix MB,
  563.                      unsigned htA, unsigned lenA, unsigned lenB );
  564.  
  565. /*************  Two-Dimensional Fourier-Transform Methods *****************/
  566.  
  567. void  __vf   MCElFFT( cePMatrix MY, cePMatrix MX,
  568.                       unsigned ht, unsigned len, int dir );
  569. void  __vf   MCElfilter( cePMatrix MY, cePMatrix MX, cePMatrix MFlt,
  570.                          unsigned ht, unsigned len );
  571. void  __vf   MCEsFFT( cePMatrix MY, cePMatrix MX,
  572.                       unsigned ht, unsigned len, int dir );
  573. void  __vf   MCEsfilter( cePMatrix MY, cePMatrix MX, cePMatrix MFlt,
  574.                          unsigned ht, unsigned len );
  575.  
  576.       /*************  Input and Output  ****************/
  577.  
  578. void __vf MCEfprint( FILE _VFAR *stream, cePMatrix MA, unsigned ht,
  579.                     unsigned len, unsigned linewidth );
  580. #ifndef _Windows
  581.     void __vf MCEcprint( cePMatrix MA, unsigned ht, unsigned len );
  582. #endif
  583. void  __vf    MCEwrite( FILE _VFAR *stream, cePMatrix X, unsigned ht, unsigned len  );
  584. void  __vf    MCEread( cePMatrix X, unsigned ht, unsigned len, FILE _VFAR *stream );
  585.  
  586. #ifdef __cplusplus
  587. }
  588. #endif